// 获取今日之后的近一年日期
export function getTimePicker() {
  // 获取今天的日期
  const today = new Date();

  // 初始化一个空数组，用于存储日期时间数据
  const dateTimeData = [];

  // 循环获取今天之后一年的日期时间数据
  for (let i = 0; i < 365; i++) {
    // 创建一个新的日期对象，增加 i 天
    const date = new Date(today);
    date.setDate(today.getDate() + i);

    // 构建日期时间对象
    const year = date.getFullYear();
    const month = date.getMonth() + 1; // 月份从 0 开始
    const day = date.getDate();
    // const hours = date.getHours();
    // const minutes = date.getMinutes();
    // const seconds = date.getSeconds();

    // 构建树形结构
    const yearObj = dateTimeData.find(item => item.text === year);
    if (!yearObj) {
      // 如果该年份不存在，则创建
      dateTimeData.push({ text: year, children: [] });
    }

    const monthObj = dateTimeData.find(item => item.text === year).children.find(item => item.text === month);
    if (!monthObj) {
      // 如果该月份不存在，则创建
      dateTimeData.find(item => item.text === year).children.push({ text: month, children: [] });
    }

    const dayObj = dateTimeData.find(item => item.text === year).children.find(item => item.text === month).children.find(item => item.text === day);
    if (!dayObj) {
      // 如果该日期不存在，则创建
      dateTimeData.find(item => item.text === year).children.find(item => item.text === month).children.push({
        text: day,
        children: []
      });
    }

    // // 将时分秒作为子节点添加
    // dateTimeData.find(item => item.text === year).children.find(item => item.text === month).children.find(item => item.text === day).children.push({
    //   text: `${hours}:${minutes}:${seconds}`
    // });
  }

  return dateTimeData
}

export function getWeeklyDatesStartingSundayUntilHalfYearLater() {
  // 设置起始日期为2024年的第一个星期日，通过找到该年第一个周一再减一天来实现
  const startDate = new Date(2024, 0, 1);
  while (startDate.getDay() !== 0) { // 调整到最近的星期日
    startDate.setDate(startDate.getDate() - 1);
  }

  // 获取今天的日期
  const today = new Date();

  // 计算半年后的日期
  const halfYearLater = new Date(today.getTime());
  halfYearLater.setMonth(today.getMonth() + 6);

  // 初始化结果二维数组
  const allDates = [];
  let currentDate = new Date(startDate);

  // 遍历直到超过半年后的日期
  while (currentDate <= halfYearLater) {
    // 本周日期数组
    const weekDates = [];

    // 从周日开始，遍历7天
    for (let i = 0; i < 7; i++) {
      weekDates.push({
        date: formatDate(currentDate)
      });
      currentDate.setDate(currentDate.getDate() + 1);
    }
    // 将本周的日期添加到结果数组
    allDates.push(weekDates);
  }

  // 处理最后一周可能不满7天的情况，用空字符串填充
  const lastWeek = allDates[allDates.length - 1];
  while (lastWeek.length < 7) {
    lastWeek.push({
      date: ''
    });
  }

  allDates.forEach((weekDates, index) => {
    weekDates.forEach((dateItem, dayIndex) => {
      // 标记日期
      if (dateItem.date == formatDate(today)) {
        dateItem.type = `today`;
      } else if (new Date(dateItem.date) < today) {
        dateItem.type = `history`;
      } else {
        dateItem.typ = `next`;
      }

      // // 添加年份信息到每周的最后一项
      // if (dayIndex === 6) { // 周日，即一周的最后一天
      //   const dateObj = new Date(dateItem.date);
      //   const year = dateObj.getFullYear();
      //   weekDates.push(`本周末属于${year}年`);
      // }
    });
  });

  return allDates;
}

// 获取今年每周的日期信息
export function getWeeklyArray() {
  const weeklyArray: Array<Array<Date>> = new Array(52)
  const currentYear = new Date().getFullYear()
  // 获取每年的第一天
  let startDate = new Date(currentYear, 0, 1)
  // 获取第一天是第一周的星期几
  let startIdx = startDate.getDay()
  let startWeek = 0;

  // 第一周可能需要填充前面的null，不然遍历的时候会少元素
  if (0 < startIdx) {
    weeklyArray[0] = new Array(7)

    for (let i = 0; i < 7; i++) {
      if (i < startIdx) {
        weeklyArray[0][i] = null
      } else {
        weeklyArray[0][i] = startDate
        startDate = new Date(startDate.getTime() + (60 * 60 * 24 * 1000))
      }
    }

    startWeek = 1
  }

  for (let week = startWeek; week < 53; week++) {
    weeklyArray[week] = new Array(7)

    for (let i = 0; i < 7; i++) {
      // 最后一周同理，超过今年的需要填充null，不然遍历的时候会少元素
      if (startDate.getFullYear() > currentYear) {
        weeklyArray[week][i] = null
      } else {
        weeklyArray[week][i] = startDate
        startDate = new Date(startDate.getTime() + (60 * 60 * 24 * 1000))
      }
    }
  }

  return weeklyArray
}

// 获取日期属于对应年的第几周
export function getYearWeek(date: Date) {
  const date2 = new Date(date.getFullYear(), 0, 1)
  const d = Math.round((date.valueOf() - date2.valueOf()) / 86400000)
  return Math.ceil((d + ((date2.getDay() + 1) - 1)) / 7)
}

// 获取日期格式
export function formatDate(date, type?, formatType = '-') {
  const year = date.getFullYear();
  const month = (date.getMonth() + 1).toString().padStart(2, '0');
  const day = date.getDate().toString().padStart(2, '0');
  const hours = date.getHours().toString().padStart(2, '0');
  const minutes = date.getMinutes().toString().padStart(2, '0');
  const seconds = date.getSeconds().toString().padStart(2, '0');
  let endTime = ''
  if (type === 'hh:mm') {
    return `${hours}:${minutes}`;
  }
  if (type === 'YYYY/MM/DD HH:mm:ss') {
    endTime = `${hours}:${minutes}:${seconds}`;
  }
  if (type === 'YYYY/MM/DD HH:mm') {
    endTime = `${hours}:${minutes}`;
  }
  return `${year}${formatType}${month}${formatType}${day}${endTime ? ` ${endTime}` : ''}`;
}

// 计时
export async function countDownLatch(count: number) {
  while (count > 0) {
    await sleep(20);
    count--;
  }
}
// 睡眠
function sleep(ms: number):Promise<void> {
  return new Promise(resolve => setTimeout(resolve, ms));
}

export function mergeOverlappingRanges(arr) {
  // 首先对数组进行排序，确保按 start 值的升序排列
  arr.sort((a, b) => a.start - b.start);

  let merged = [];
  let current = arr[0];

  for (let i = 1; i < arr.length; i++) {
    const next = arr[i];
    // 检查当前对象和下一个对象是否重叠
    if (next.start <= current.end) {
      // 如果重叠，更新当前对象的 end 和 value
      current.end = Math.max(current.end, next.end);
      current.value += next.value.substring(next.start - current.start);
    } else {
      // 如果没有重叠，将当前对象添加到结果数组，并将下一个对象设置为当前对象
      merged.push(current);
      current = next;
    }
  }

  // 不要忘记将最后一个对象添加到结果数组中
  merged.push(current);

  return merged;
}

export function mergeOverlappingColorRanges(arr) {
  let merged = [];
  let current = null;

  for (let i = 0; i < arr.length; i++) {
    const item = arr[i];

    if (!current) {
      // 如果current为空，初始化它
      current = { ...item };
      continue;
    }

    // 检查颜色是否相同且范围是否连续或重叠
    if (
      current.color === item.color &&
        (current.end >= item.start - 1 || current.end === item.start)
    ) {
      // 如果颜色相同且范围连续或重叠，合并它们
      current.end = Math.max(current.end, item.end);
      // current.value += item.value.substring(item.start - current.start);
    } else {
      // 如果不连续或颜色不同，则将当前对象添加到结果数组，并重置current
      merged.push(current);
      current = { ...item };
    }
  }

  // 不要忘记将最后一个对象添加到结果数组中
  if (current) {
    merged.push(current);
  }

  return merged;
}


export function cancelRangeAndMerge(data, cancelStart, cancelEnd) {
  // 辅助函数：拆分一个对象，返回拆分后的对象数组
  function splitObject(obj, cancelStart, cancelEnd) {
    const result = [];
    if (obj.start < cancelStart) {
      // 在取消范围之前有文本，创建新对象表示这部分
      result.push({
        start: obj.start,
        end: cancelStart,
        value: obj.value.substring(0, cancelStart - obj.start),
        isWeight: obj.isWeight
      });
    }
    if (obj.end > cancelEnd) {
      // 在取消范围之后有文本，创建新对象表示这部分
      result.push({
        start: cancelEnd,
        end: obj.end,
        value: obj.value.substring(cancelEnd - obj.start),
        isWeight: obj.isWeight
      });
    }
    return result;
  }

  // 1. 遍历合并后的对象数组
  let newMergedData = data.reduce((acc, obj) => {
    // 2. 检查对象的value是否包含要取消的范围
    if (obj.start <= cancelEnd && obj.end >= cancelStart) {
      // 3. 如果包含，根据取消范围拆分当前对象
      const splitObjs = splitObject(obj, cancelStart, cancelEnd);
      // 将拆分后的对象添加到结果数组中（不包括被完全取消的对象）
      acc.push(...splitObjs);
    } else {
      // 如果不包含，则保留当前对象
      acc.push(obj);
    }
    return acc;
  }, []);

  // 4. 最后，合并剩余的对象（此步骤可能需要再次执行合并重叠范围的逻辑）
  return mergeOverlappingRanges(newMergedData);
}

export function getFontWeight (selectedText, index) {
  let fontWeight = 400
  if (!selectedText || !selectedText.length) {
    return fontWeight
  }
  selectedText.forEach(item => {
    if (index >= item.start && index <= item.end) {
      fontWeight = 600
    }
  })
  return fontWeight
}

export function getFontColor (selectedTextColor, index) {
  let color = '#fff'
  if (!selectedTextColor || !selectedTextColor.length) {
    return color
  }
  selectedTextColor.forEach(item => {
    if (index >= item.start && index <= item.end) {
      color = item.color
    }
  })
  return color
}

export function rgbToHsl (r, g, b) {
  r /= 255, g /= 255, b /= 255;
  const max = Math.max(r, g, b), min = Math.min(r, g, b);
  let h, s, l = (max + min) / 2;

  if(max == min){
    h = s = 0; // achromatic
  } else {
    const d = max - min;
    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
    switch(max){
      case r: h = (g - b) / d + (g < b ? 6 : 0); break;
      case g: h = (b - r) / d + 2; break;
      case b: h = (r - g) / d + 4; break;
    }
    h /= 6;
  }
  return [h, s, l];
}

export function hslToHex(h, s, l) {
  l /= 100;
  const a = s * Math.min(l, 1 - l) / 100;
  const f = n => {
    const k = (n + h / 30) % 12;
    const color = l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
    return Math.round(255 * color).toString(16).padStart(2, '0');   // convert to Hex and prefix "0" if needed
  };
  return `#${f(0)}${f(8)}${f(4)}`;
}

export function calculateAndCountdown(startDateStr, duration) {
  // 将会议开始日期字符串转为Date对象
  const startDate = new Date(startDateStr.replace(/(\d{4})\/(\d{2})\/(\d{2})/, '$1-$2-$3').replace(/ /, 'T'));
  // 将持续时间从分钟转换为毫秒
  const durationMs = duration * 60 * 1000;
  // 计算会议结束时间
  const endTime = new Date(startDate.getTime() + durationMs);

  // 获取当前时间
  const now = new Date();

  // 计算已过去的时长（毫秒）
  const elapsedTime = now > endTime ? 0 : endTime.getTime() - now.getTime();

  // 如果会议已结束，显示提示信息
  if (elapsedTime <= 0) {
    // console.log("会议已结束");
    return {
      type: 'end',
      time: `已结束`
    }
  } else {
    // 计算已过去的时长（小时、分钟、秒）
    const hours = Math.floor(elapsedTime / (1000 * 60 * 60));
    const minutes = Math.floor((elapsedTime % (1000 * 60 * 60)) / (1000 * 60));
    const seconds = Math.floor((elapsedTime % (1000 * 60)) / 1000);
    return {
      type: 'ing',
      endTime,
      time: `${hours ? hours + ':' : ''}${minutes}:${seconds}`
    }
    // // 启动倒计时至会议结束
    // countdown(endTime);
  }
}

export function processAndSortData(list) {
  const data = [...list.meetingData, ...list.inMeetingData]
  // 遍历数据，检查并更新过期状态
  data.forEach(item => {
    item.isFinish = false
    item.isStart = false
    if (isFinish(item)) {
      item.isFinish = true
    }
    if (isStart(item)) {
      item.isStart = true
    }
    if (item.status === 0 && isExpired(item)) {
      item.status = -1;
    }
  });

  // 定义排序函数
  return data.sort((a, b) => {
    // 直接按status排序，确保1 > 0 > 2 > -1
    if (a.status !== b.status) {
      return b.status - a.status || a.status - b.status; // 优先比较绝对值，然后考虑正负
    }

    // 对于status相同的项，按startTime升序排列
    return Number(new Date(a.startTime).getTime()) - Number(new Date(b.startTime).getTime());
  });
}

// 检查是否已经超过开始时间但是还没结束的函数保持不变
function isFinish(item) {
  const currentTime = new Date();
  const startTime = new Date(item.startTime);
  const endTime = new Date(item.startTime);
  endTime.setMinutes(endTime.getMinutes() + item.duration);
  return startTime < currentTime && endTime > currentTime;
}

// 检查是否即将开始时间函数保持不变
function isStart(item) {
  const currentTime = new Date();
  const startTime = new Date(item.startTime);
  // 将时间转换为分钟数
  const minutes1 = currentTime.getHours() * 60 + currentTime.getMinutes();
  const minutes2 = startTime.getHours() * 60 + startTime.getMinutes();

  // 计算两个时间的分钟数之差
  const minutesDifference = minutes2 - minutes1;

  // 如果差值小于30分钟，则小于半个小时
  return minutesDifference < 30 && minutesDifference > 0;
  return startTime > currentTime
}

// 检查是否过期的函数保持不变
function isExpired(item) {
  const currentTime = new Date();
  const endTime = new Date(item.startTime);
  endTime.setMinutes(endTime.getMinutes() + item.duration);
  return endTime < currentTime;
}